home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Pascal / Code Resources / Eclectic CDEFs / CDEF Utilities / StubCDEF Folder / StubCDEFIntf.p < prev   
Text File  |  1997-02-27  |  5KB  |  148 lines
  1. {    StubCDEFIntf    }
  2. {}
  3. {    Interface to the StubCDEF control    }
  4. {}
  5. {    Copyright © Sebastiano Pilla 1996    }
  6. {    All rights reserved    }
  7.  
  8. {    <mailto:case@tvol.it>    }
  9.  
  10. {    This unit handles the creation and initialization of a control with the stub method    }
  11.  
  12. unit StubCDEFIntf;
  13.  
  14.  
  15. interface
  16.  
  17.  
  18. {    InstallRealCDEFUPP    }
  19. {}
  20. {    Loads a control template and installs the real control definition procedure into the refCon; also initializes    }
  21. {    the control by calling explicitly the given defproc with the initCntl message    }
  22. {}
  23. {    Entry:    inControlDefProcPtr = pointer to the real control definition    }
  24. {            inWindPtr = pointer to the window to which the control belongs    }
  25. {            inCtrlTemplateID = res. ID of a CNTL resource, whose procID field is defined as    }
  26. {                (16 * StubCDEF resource ID) + variation code    }
  27. {    Exit:    outControlHdl = handle to newly created control (or NIL if errors)    }
  28. {            function result = result given by the real defproc to the initCntl message    }
  29.     function InstallRealCDEFUPP (var outControlHdl: ControlHandle;
  30.                                     inControlDefProcPtr: ControlDefProcPtr;
  31.                                     inWindPtr: WindowPtr;
  32.                                     inCtrlTemplateID: SInt16): SInt32;
  33.  
  34.  
  35. {    AttachRealCDEFUPP    }
  36. {}
  37. {    Attaches the given control definition procedure to an already created control, and calls the defproc    }
  38. {    explicitly with the initCntl message    }
  39. {}
  40. {    Entry:    inControlDefProcPtr = pointer to the real control definition    }
  41. {            inControlHdl = handle to a control    }
  42. {    Exit:    function result = result given by the real defproc to the initCntl message    }
  43.     function AttachRealCDEFUPP (inControlDefProcPtr: ControlDefProcPtr;
  44.                                     inControlHdl: ControlHandle): SInt32;
  45.  
  46.  
  47. {    RemoveRealCDEFUPP    }
  48. {}
  49. {    Calls the control's defproc with the dispCntl message and removes the defproc from the given control's refCon    }
  50. {}
  51. {    Entry:    inControlHdl = handle to control    }
  52. {    Exit:    function result = result given by the real defproc to the dispCntl message    }
  53.     function RemoveRealCDEFUPP (inControlHdl: ControlHandle): SInt32;
  54.  
  55.  
  56. implementation
  57.  
  58.  
  59.     const
  60.         kCNTLResType = 'CNTL';
  61.  
  62.  
  63.     function InstallRealCDEFUPP (var outControlHdl: ControlHandle;
  64.                                     inControlDefProcPtr: ControlDefProcPtr;
  65.                                     inWindPtr: WindowPtr;
  66.                                     inCtrlTemplateID: SInt16): SInt32;
  67.         var
  68.             ctrlDefUPP: ControlDefUPP;
  69.             result: SInt32;
  70.     begin
  71.         outControlHdl := nil;
  72.         result := 0;
  73.  
  74. { Get the control from the resource file and install it into the given window's controls list }
  75.         outControlHdl := GetNewControl(inCtrlTemplateID, inWindPtr);
  76.  
  77.         if outControlHdl <> nil then
  78.             begin
  79.  
  80.     { Create the control definition UPP }
  81.                 ctrlDefUPP := NewControlDefProc(inControlDefProcPtr);
  82.  
  83.     { Store the control definition UPP into the control's refCon }
  84.                 SetControlReference(outControlHdl, SInt32(ctrlDefUPP));
  85.  
  86.     { Call explicitly the control defProc with the initCntl message; this is necessary to have the control's }
  87.     { defProc properly do its initialization, because this message has been sent at the time of the GetNewControl }
  88.     { call to the stub, which obviously cannot know anything about our particular control }
  89.                 result := CallControlDefProc(GetControlVariant(outControlHdl), outControlHdl, initCntl, 0, ctrlDefUPP);
  90.             end;
  91.  
  92.         InstallRealCDEFUPP := result;
  93.     end;
  94.  
  95.  
  96.     function AttachRealCDEFUPP (inControlDefProcPtr: ControlDefProcPtr;
  97.                                     inControlHdl: ControlHandle): SInt32;
  98.         var
  99.             ctrlDefUPP: ControlDefUPP;
  100.             result: SInt32;
  101.     begin
  102.         result := 0;
  103.  
  104.         if inControlHdl <> nil then
  105.             begin
  106.  
  107.     { Create the control definition UPP }
  108.                 ctrlDefUPP := NewControlDefProc(inControlDefProcPtr);
  109.  
  110.     { Store the control definition UPP into the control's refCon }
  111.                 SetControlReference(inControlHdl, SInt32(ctrlDefUPP));
  112.  
  113.     { Call explicitly the control defProc with the initCntl message; this is necessary to have the control's }
  114.     { defProc properly do its initialization, because this message has been sent at the time of the GetNewControl }
  115.     { call to the stub, which obviously cannot know anything about our particular control }
  116.                 result := CallControlDefProc(GetControlVariant(inControlHdl), inControlHdl, initCntl, 0, ctrlDefUPP);
  117.             end;
  118.  
  119.         AttachRealCDEFUPP := result;
  120.     end;
  121.  
  122.  
  123.     function RemoveRealCDEFUPP (inControlHdl: ControlHandle): SInt32;
  124.         var
  125.             ctrlDefUPP: ControlDefUPP;
  126.             result: SInt32;
  127.     begin
  128.         result := 0;
  129.  
  130.         if inControlHdl <> nil then
  131.             begin
  132.                 ctrlDefUPP := ControlDefUPP(GetControlReference(inControlHdl));
  133.  
  134.                 if ctrlDefUPP <> nil then
  135.                     begin
  136.  
  137.         { Call explicitly the control defProc with the dispCntl message; this is necessary to the real defProc to properly }
  138.         { deallocate any private storage, ecc. This message cannot be understood by the stub procedure, which obviously }
  139.         { cannot know anything about our control }
  140.                         result := CallControlDefProc(GetControlVariant(inControlHdl), inControlHdl, dispCntl, 0, ctrlDefUPP);
  141.                         DisposeRoutineDescriptor(ctrlDefUPP);
  142.                     end;
  143.             end;
  144.         RemoveRealCDEFUPP := result;
  145.     end;
  146.  
  147.  
  148. end.